1. Field of the Invention
The present invention relates to compilers for computer programing languages, and more particularly relates to a system and method for an extensible incremental compiler and extension mechanisms for same.
2. Description of the Related Art
Compilers are computer programs which translate input programs from a human readable programing language to one or more computer readable files. Compilers are employed in most high level programing languages such as Pascal, Fortran, C and C++. Conventional compilers operate on an entire input file, referred to as source code and generate the computer readable files which are referred to as the object code. This process demands a great deal of computer resources when large files are being compiled.
In order to make the compilation process more efficient, compilers have been developed which determine where changes have been made in the source code and only act upon those sections and any sections of code which depends therefrom. These compilers are known as incremental compilers. For example, techniques for implementing a limited form of incremental compilation have been developed in which a tool called "make" determines which files need to be recompiled based upon time stamps entered after the last compilation process. The "make" tool then directs the compiler to act upon the necessary sections of the source code.
While incremental compilers are known in the art, those compilers which are currently available are constrained to a set of features which are provided by the base compiler. In other words, the compiler and its processes are non-extensible. As a result, either compiler providers are forced to implement a great deal of features which will rarely be used, resulting in undesirable overhead, or compiler users must accept a limited set of features integral to the compiler.
In the past, efforts have been made to provide a compiler with more flexibility. For example, in LISP systems, a metaobject protocol is employed to provide expanded functionality. However, rather than merely augmenting the compilation process, metaobject protocols form the basis for language design by providing a framework for specifying language semantics as well as their associated compiler operations.
Alternatively, a compiler provider can make the source code of the compiler available to end users who wish to add functionality. However, this requires altering and recompiling the underlying compiler each time a new function is required. It also requires freely circulating the source code for the compiler, making it available to would be competitors for copying. In addition, once the compiler source code is modified, subsequent product maintenance by the supplier is virtually impossible.
Accordingly, there remains a need in the art for an incremental language compiler which is extensible to augment the compilation process without altering the well defined, underlying programing language or compiler.